/*
* 此函数可用来实现C对于P的继承，通过原型链，原型是父构造函数的一个实例化对象
* 此处能够继承父构造函数中添加到this的属性和方法，也能继承父构造函数的原型上的属性和方法，但不能传递参数
* */
function inheritByPrototypeAndObj(C, P){
    C.prototype = new P();
};


/*
*  此种继承方法，可以传递参数，但是不能继承父构造函数的原型方法
* */
//inheritByParentConstructFun
var Parent = function(a, b, c, d) {

};
var Child = function(a, b, c, d, e) {
    Parent.call(this,args, a, b, c, d);
}

/*
* 借用构造函数，并同时引用父构造函数实例对象作为原型，但父构造函数被调用两次，效率极低
* */
var Parent = function(a, b, c, d) {

};
var Child = function(a, b, c, d, e) {
    Parent.call(this,args, a, b, c, d);
}
Child.prototype = new Parent();

/*
*  公用原型对象，但容易修改原型对象
* */
function inheritBySamePrototype(C, P) {
    C.prototype = P.prototype;
}

/*
* 临时构造函数，此方法类似公用原型对象，但不是直接引用父构造函数的原型，通过一个临时的构造函数为桥梁来引用，避免对父构造函数的原型的修稿
* 并且还可以设置一个类似的超类的属性，来直接指向父构造函数的原型
* */
function inheritBySamePrototype(C, P) {
    var F = function() {};
    F.prototype = P.prototype;
    C.prototype = new F();
    C.uber = P.prototype;               //“超类”的对父构造函数的引用
}

/*
* 现在就对上述的所有东西进行合并，并重置构造函数的指针，因为基本上子构造函数的实例对象的构造指针都会指向父构造函数
* */

function inherit(C, P) {
    var F = function() {};
    F.prototype = P.prototype;
    C.prototype = new F();
    C.uber = P.prototype;               //“超类”的对父构造函数的引用
    C.prototype.constructor = C;
}
function Parent() {};
function Child() {
    var args = Array.prototype.slice.apply(arguments);
    Parent.apply(args);
};
inherit(Child, Parent);

/*
* 对上述的优化-----使用即时函数避免每次都要创建F()这个临时构造函数
* 此模式比较正式的定名为代理函数模式或者代理构造函数模式
* */
var inherit = (function() {
    var F = function() {};
    return function(C, P){
        F.prototype = P.prototype;
        C.prototype = new F();
        C.uber = P.prototype;               //“超类”的对父构造函数的引用
        C.prototype.constructor = C;
    };
}());
function Parent() {};
function Child() {
    var args = Array.prototype.slice.apply(arguments);
    Parent.apply(args);
};
inherit(Child, Parent);

